#include "../include/Parser.h"
#include <iostream>
#include <algorithm>

Parser::Parser() : current_line(0) {}

std::string Parser::trim(const std::string& str) {
    size_t first = str.find_first_not_of(' ');
    if (first == std::string::npos) return "";
    size_t last = str.find_last_not_of(' ');
    return str.substr(first, (last - first + 1));
}

int Parser::get_indent_level(const std::string& line) {
    int indent = 0;
    for (char c : line) {
        if (c == ' ') {
            indent++;
        } else {
            break;
        }
    }
    return indent;
}

std::pair<std::string, std::string> Parser::parse_node_info(const std::string& line) {
    std::string trimmed = trim(line);
    
    // 检查是否有括号包含的值
    size_t open_paren = trimmed.find('(');
    size_t close_paren = trimmed.find(')');
    
    if (open_paren != std::string::npos && close_paren != std::string::npos) {
        std::string node_type = trim(trimmed.substr(0, open_paren));
        std::string value = trim(trimmed.substr(open_paren + 1, close_paren - open_paren - 1));
        return std::make_pair(node_type, value);
    } else {
        return std::make_pair(trimmed, "");
    }
}

std::unique_ptr<ASTNode> Parser::parse_file(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "Error: Cannot open file " << filename << std::endl;
        return nullptr;
    }
    
    // 读取所有行
    lines.clear();
    std::string line;
    while (std::getline(file, line)) {
        lines.push_back(line);
    }
    file.close();
    
    current_line = 0;
    return parse_node();
}

std::unique_ptr<ASTNode> Parser::parse_node(int expected_indent) {
    if (current_line >= lines.size()) {
        return nullptr;
    }
    
    std::string line = lines[current_line];
    int indent = get_indent_level(line);
    
    // 如果缩进不匹配，返回nullptr
    if (indent < expected_indent) {
        return nullptr;
    }
    
    // 解析节点信息
    auto [node_type, value] = parse_node_info(line);
    
    // 创建节点
    auto node = create_node(node_type, value);
    if (!node) {
        std::cerr << "Error: Unknown node type " << node_type << std::endl;
        return nullptr;
    }
    
    current_line++;
    
    // 解析子节点
    while (current_line < lines.size()) {
        int child_indent = get_indent_level(lines[current_line]);
        if (child_indent <= indent) {
            break; // 子节点结束
        }
        
        auto child = parse_node(indent + 1);
        if (child) {
            node->add_child(std::move(child));
        }
    }
    
    return node;
}

std::unique_ptr<ASTNode> Parser::create_node(const std::string& node_type, const std::string& value) {
    // 程序结构
    if (node_type == "Program") {
        return std::make_unique<ProgramNode>();
    } else if (node_type == "CompUnit") {
        return std::make_unique<CompUnitNode>();
    }
    
    // 声明
    else if (node_type == "ConstDecl") {
        return std::make_unique<ConstDeclNode>();
    } else if (node_type == "VarDecl") {
        return std::make_unique<VarDeclNode>();
    } else if (node_type == "ConstDef") {
        return std::make_unique<ConstDefNode>(value);
    } else if (node_type == "VarDef") {
        return std::make_unique<VarDefNode>(value);
    }
    
    // 函数
    else if (node_type == "FuncDef") {
        return std::make_unique<FuncDefNode>(value);
    } else if (node_type == "FuncFParam") {
        return std::make_unique<FuncFParamNode>(value);
    } else if (node_type == "FuncFParams") {
        return std::make_unique<FuncFParamsNode>();
    }
    
    // 语句
    else if (node_type == "Block") {
        return std::make_unique<BlockNode>();
    } else if (node_type == "AssignStmt") {
        return std::make_unique<AssignStmtNode>();
    } else if (node_type == "ExprStmt") {
        return std::make_unique<ExprStmtNode>();
    } else if (node_type == "ReturnStmt") {
        return std::make_unique<ReturnStmtNode>();
    } else if (node_type == "IfStmt") {
        return std::make_unique<IfStmtNode>();
    }
    
    // 表达式
    else if (node_type == "BinaryExpr") {
        return std::make_unique<BinaryExprNode>(value);
    } else if (node_type == "UnaryExpr") {
        return std::make_unique<UnaryExprNode>(value);
    } else if (node_type == "CallExpr") {
        return std::make_unique<CallExprNode>(value);
    } else if (node_type == "IdentExpr") {
        return std::make_unique<IdentExprNode>(value);
    } else if (node_type == "LiteralExpr") {
        // 正确解析LiteralExpr，value格式为 "int: 0"  
        return std::make_unique<LiteralExprNode>(value, "");
    } else if (node_type == "ParenExpr") {
        return std::make_unique<ParenExprNode>();
    }
    
    // 基本类型
    else if (node_type == "BasicType") {
        return std::make_unique<BasicTypeNode>(value);
    }
    
    // 其他
    else if (node_type == "InitVal") {
        return std::make_unique<InitValNode>();
    } else if (node_type == "ConstInitVal") {
        return std::make_unique<ConstInitValNode>();
    }
    
    return nullptr;
} 